/**
 * Proyecto: Cognitum
 * Global IT Services 2008
 * @author Esanantonio
 * @author Mislas
 */
Cognitum.Polizas.General.Editor = Ext.extend(Karma.EBCard, {

    esFlotilla: null,
    
    initComponent: function(){
        var _sections = [{
            xtype: 'pol.ctls.gral',
			division: this.Division,
            esFlotilla: this.esFlotilla,
            title: 'Caratula'
        }, {
            title: 'Administracion',
            items: [{
                fieldLabel: 'Director',
                name: 'Director',
                entityName: 'Usuario',
                xtype: 'entity.link'
            }, {
                fieldLabel: 'Ejecutivo',
                name: 'Ejecutivo',
                entityName: 'Usuario',
                xtype: 'entity.link'
            }, {
                fieldLabel: 'Supervisor',
                name: 'Supervisor',
                entityName: 'Usuario',
                xtype: 'entity.link'
            }, {
                fieldLabel: 'Grupo',
                name: 'Grupo',
                entityName: 'Grupos',
                xtype: 'entity.link'
            }, {
                fieldLabel: 'Ejecutivo Aseguradora',
                name: 'EjecutivoAseguradora',
                entityName: 'Contacto Persona Moral',
                xtype: 'entity.link',
                contextTriggers: [{
                    id: 'Aseguradora',
                    query: 'p.PersonaMoral.Id=?'
                }]
            }, {
                xtype: 'datefield',
                fieldLabel: 'Fecha emision',
                name: 'FechaEmision'
            }, {
                xtype: 'datefield',
                fieldLabel: 'Fecha envio',
                name: 'FechaEnvio'
            }, {
                fieldLabel: 'Negociación',
                name: 'Negociacion',
                entityName: 'Negociaciones',
                xtype: 'entity.link',
                allowBlank: true
                
            }],
            updateControls: function(value){
                if (Ext.isEmpty(value)) {
                    return;
                }
                if (value.EstatusPoliza >0 && value.EstatusPoliza < 6) {
                    this.disable();
                }
            }
        }, {
            title: 'Slip',
			propertyName: 'Slip',
			items: [{
			    fieldLabel: 'Id',
			    name: 'Id',
			    xtype: 'hidden',
			    allowBlank: true
			}, {
                xtype: 'htmleditor',
                name: 'Descripcion',
                hideLabel: true,
                anchor: '99% 99%'
            }],
            updateControls: function(value){
                if (Ext.isEmpty(value)) {
                    return;
                }
                if (value.EstatusPoliza >= 1) {
                    this.disable();
                }
            }
        }, {
            title: 'Endosos',
            items: [{
                fieldLabel: 'Endosos',
                name: 'Endosos',
                entityName: 'Endosos',
                xtype: 'ag.list',
                hideLabel: true,
                context: 'e.Poliza.Id=?',
                anchor: '99% 99%',
                updateControls: function(value){
                    if (Ext.isEmpty(value)) {
                        return;
                    }
                    // menu config
                    this.canUpdate = this.canUpdate && value.EstatusPoliza == 1;
                    this.deleteMenuAction.setDisabled(!(this.canDelete && value.EstatusPoliza == 1));
                    this.newMenuAction.setDisabled(!(this.canNew && value.EstatusPoliza == 1));
                    this.newToolbarButton.setDisabled(!(this.canNew && value.EstatusPoliza == 1));
                }
            }]
            
        }, {
            title: 'Siniestros',
            items: [{
                fieldLabel: 'Siniestros',
                hideLabel: true,
                name: 'Siniestros',
                context: 's.Poliza.Id=?',
                entityName: 'Siniestros',
                xtype: 'ag.list',
                anchor: '99% 99%',
                updateControls: function(value){
                    if (Ext.isEmpty(value)) {
                        return;
                    }
                    // menu config
                    this.canUpdate = this.canUpdate && value.EstatusPoliza <= 1;
                    this.deleteMenuAction.setDisabled(!(this.canDelete && value.EstatusPoliza <= 1));
                    this.newMenuAction.setDisabled(!(this.canNew && value.EstatusPoliza <= 1));
                    this.newToolbarButton.setDisabled(!(this.canNew && value.EstatusPoliza <= 1));
                }
            }]
        }, {
            title: 'Documentos',
            items: [{
                fieldLabel: 'Documentos',
                hideLabel: true,
                name: 'Documentos',
                entityName: 'DocumentoDigitalizadoPoliza',
                xtype: 'ag.list',
                context: 'd.Poliza.Id=?',
                anchor: '99% 99%'
            }]
        }, {
            title: 'Recibos',
            items: [{
                hideLabel: true,
                name: 'Recibos',
                entityName: 'Recibos',
                xtype: 'ag.list',
                context: 'r.Tramite.Id=?',
                anchor: '99% 99%',
                updateControls: function(value) {
                    LOG.debug('Recibo Ag.list updateControls <-');
                    if (Ext.isEmpty(value)) {
                        return;
                    }                    
                    // menu config
                    this.canUpdate = value.EstatusPoliza == 1;
                    this.deleteMenuAction.setDisabled(!(this.canDelete && value.EstatusPoliza == 1));
                    this.newMenuAction.setDisabled(!(this.canNew && value.EstatusPoliza == 1));
                    this.newToolbarButton.setDisabled(!(this.canNew && value.EstatusPoliza == 1));
                    LOG.debug('Recibo Ag.list updateControls ->');
                }
            }]
        }, {
            title: 'Comisiones',
            items: [{
                hideLabel: true,
                name: 'Comisiones',
                entityName: 'ComisionesAsociados',
                xtype: 'ag.list',
                context: 'c.Poliza.Id=?',
                anchor: '99% 99%',
                updateControls: function(value){
                    if (Ext.isEmpty(value)) {
                        return;
                    }
                    // menu config
                    this.canUpdate = this.canUpdate && value.EstatusPoliza == 0;
                    this.deleteMenuAction.setDisabled(!(this.canDelete && value.EstatusPoliza == 0));
                    this.newMenuAction.setDisabled(!(this.canNew && value.EstatusPoliza == 0));
                    this.newToolbarButton.setDisabled(!(this.canNew && value.EstatusPoliza == 0));
                }
            }]
        }, {
            title: 'Bitacora',
            items: [{
                fieldLabel: 'Bitacoras',
                hideLabel: true,
                name: 'Bitacoras',
                entityName: 'BitacorasTramite',
                xtype: 'ag.list',
                context: 'b.Tramite.Id=?',
                anchor: '99% 99%'
            }]
        }, {
            xtype: 'sec.editor',
            title: 'Seguridad'
        }, {
            xtype: 'aud.editor',
            title: 'Auditoria'
        }];
        
        if (this.seccionesAdicionales) {
            Ext.each(this.seccionesAdicionales, function(item){
                _sections.push(item);
            }, this);
        }
        Ext.apply(this, {
            sections: _sections
        });
        
        this.addEvents({
            'newOT': true,
            'descartar': true,
            'cancelar': true,
            'renovar': true
        });
        Cognitum.Polizas.General.Editor.superclass.initComponent.apply(this, arguments);
    },
    
    getTBarCustomControls: function(){
        return [this.descartarBtn = new Ext.Button({
            text: 'Descartar',
            handler: this.onDescartar,
            scope: this
        }), this.renovarBtn = new Ext.Button({
            text: 'Renovar',
            handler: this.onRenovar,
            scope: this
        }), this.cancelarBtn = new Ext.Button({
            text: 'Cancelar',
            handler: this.onCancelar,
            scope: this
        }), this.mesaDeControlMenu = new Ext.Button({
			text: 'Mesa de Control',
            hidden: true,
			menu: {
				items: [
	                this.mesaCtlEnviarBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Enviar Mesa de Control',
	                    handler: this.onEnviarMesaControl,
	                    scope: this
	                }), this.mesaCtlOTConErroresBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Marcar OT Errores',
	                    handler: this.onMarcarOTConErrores,
	                    scope: this
	                }), this.mesaCtlCorrectoBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Marcar Correcto',
	                    handler: this.onMarcarCorrecto,
	                    scope: this
	                }), this.mesaCtlConErroresBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Marcar con Errores',
	                    handler: this.onMarcarConErrores,
	                    scope: this
	                }), this.mesaCtlIncorrectoBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Rechazar Poliza con Errores',
	                    handler: this.onRechazarConErrores,
	                    scope: this
	                }), this.mesaCtlCorrectoErroresBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Aceptar con Errores',
	                    handler: this.onAceptarConErrores,
	                    scope: this
	                }), this.mesaCtlSolicitarCorreccionBtn = new Ext.menu.Item({
	                    xtype: 'button',
	                    formBind: true,
	                    text: 'Solicitar correcciones',
	                    handler: this.onSolicitarCorrecion,
	                    scope: this
	                })
	            ]
			}
        })];
    },

    puedeEnviarMesaControl: function(value) {
        if (!this.entity.security.has('EnviarMesaControl')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusPoliza === 0) && (value.EstatusMesaDeControl === 14);
    },

    puedeMarcarCorrecto: function(value) {
        if (!this.entity.security.has('MarcarCorrecto')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusPoliza === 0) && (value.EstatusMesaDeControl === 1);
    },

    puedeMarcarConErrores: function(value) {
        if (!this.entity.security.has('MarcarConErrores')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusPoliza === 0) && (value.EstatusMesaDeControl === 1);
    },

    puedeRechazarConErrores: function(value) {
        if (!this.entity.security.has('RechazarConErrores')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusPoliza === 0) && (value.EstatusMesaDeControl === 3);
    },

    puedeMarcarOTConErrores: function(value) {
        if (!this.entity.security.has('MarcarOTConErrores')) {        
            return false;
        }        
        return (!this.isNew) && (value.EstatusPoliza === 0) && (value.EstatusMesaDeControl === 1);
    },

    puedeAceptarConErrores: function(value) {
        if (!this.entity.security.has('AceptarConErrores')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusPoliza === 0) && (value.EstatusMesaDeControl === 3);
    },

    puedeSolicitarCorreccion: function(value) {
        if (!this.entity.security.has('SolicitarCorreccion')) {
            return false;
        }
        return (!this.isNew) && (value.EstatusPoliza === 0) && 
		(value.EstatusMesaDeControl === 4 || value.EstatusMesaDeControl === 5);
    },

    onEnviarMesaControl: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onEnviarMesaControl] <-');
        }
        
        var polizaId = this.getForm().findField('Id').getValue();
        if (this.getForm().isValid())        
            Ext.Msg.show({
                title: 'Mesa de Control',
                msg: 'Estas por enviar a mesa de control, el tramite ya no podra ser modificado, deseas continuar?',
                buttons: Ext.Msg.YESNO,
                fn: function(result){
                    if (result === 'yes') {
                        this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                        this.doOperationWithParams('DoEnviarMesaControl', polizaId, {
                            fn: function(ot){
                                this.status.setStatus({
                                    text: 'La operacion fue realizada existosamente.',
                                    iconCls: 'ok-icon',
                                    clear: true
                                });
                                this.updateControls(ot);
                            },
                            scope: this
                        });
                    }
                },
                icon: Ext.MessageBox.QUESTION,
                scope: this
            });
        else
            Ext.MessageBox.alert('Error', 'El formulario contiene errores, reviselos antes de realizar la operación.');
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onEnviarMesaControl] ->');
        }
    },

    onMarcarCorrecto: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onMarcarCorrecto] <-');
        }
        var polizaId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como recibida correctamente, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                    this.doOperationWithParams('DoMarcarCorrecto', polizaId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onMarcarCorrecto] ->');
        }
    },

    onMarcarConErrores: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onMarcarConErrores] <-');
        }
        var otId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como con errores, deseas continuar?',
            buttons: Ext.Msg.YESNO,
			multiline: true,
            fn: function(result, text){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                    this.doOperationWithParams('DoMarcarConErrores', [otId, text], {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onMarcarConErrores] ->');
        }
    },

    onMarcarOTConErrores: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onMarcarOTConErrores] <-');
        }
        var otId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como con errores, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            multiline: true,
            fn: function(result, text) {
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                    this.doOperationWithParams('DoMarcarOTErrores', [otId, text], {
                        fn: function(ot) {
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onMarcarConErrores] ->');
        }
    },

    onRechazarConErrores: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onRechazarConErrores] <-');
        }
        var polizaId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como rechazada por contener errores, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                    this.doOperationWithParams('DoRechazaErrores', polizaId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onRechazarConErrores] ->');
        }
    },

    onAceptarConErrores: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onAceptarConErrores] <-');
        }
        var polizaId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por marcar la ot como aceptada pero con errores, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                    this.doOperationWithParams('DoAceptaConErrores', polizaId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onAceptarConErrores] ->');
        }
    },
    
    onSolicitarCorrecion: function(value) {
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onSolicitarCorrecion] <-');
        }
        var polizaId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Mesa de Control',
            msg: 'Estas por solicitar la correccion de los errores encontrados, deseas continuar?',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                    this.doOperationWithParams('DoSolicitaCorreccion', polizaId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La operacion fue realizada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onSolicitarCorrecion] ->');
        }
    },
    
    puedeGuardar: function(value){
        if (this.isNew) {
            return this.entity.security.New;
        }
        return (value.EstatusPoliza == 0 && 
			(value.EstatusMesaDeControl === 14 || value.EstatusMesaDeControl === 3)) 
			&& this.entity.security.Update;
    },
    
    puedeRenovar: function(value){
        if (!this.entity.security.has('Renovar')) {
            return false;
        }
        return (value.EstatusPoliza == 1 || value.EstatusPoliza == 7) && value.Renovable == 1;
    },
    
    puedeDescartar: function(value){
        if (!this.entity.security.has('Descartar')) {
            return false;
        }
        return (!this.isNew && value.EstatusPoliza === 0)  &&
               (value.EstatusMesaDeControl === 5 || value.EstatusMesaDeControl === 6);
    },
    
    puedeCancelar: function(value){
        if (!this.entity.security.has('Cancelar')) {
            return false;
        }
        return (!this.isNew && value.EstatusPoliza === 0 && 
			(value.EstatusMesaDeControl === 14 || value.EstatusMesaDeControl === 6));
    },
    
    updateControls: function(value){
        Cognitum.Polizas.General.Editor.superclass.updateControls.apply(this, arguments);
        this.guardarBtn.setDisabled(!this.puedeGuardar(value));
        this.descartarBtn.setDisabled(!this.puedeDescartar(value));
        this.cancelarBtn.setDisabled(!this.puedeCancelar(value));
        this.renovarBtn.setDisabled(!this.puedeRenovar(value));

        if (!this.isNew && value.EstatusPoliza === 0) {
            this.mesaDeControlMenu.show();

            this.mesaCtlEnviarBtn.setDisabled(!this.puedeEnviarMesaControl(value));
            this.mesaCtlConErroresBtn.setDisabled(!this.puedeMarcarConErrores(value));
            this.mesaCtlOTConErroresBtn.setDisabled(!this.puedeMarcarOTConErrores(value));
            this.mesaCtlCorrectoBtn.setDisabled(!this.puedeMarcarCorrecto(value));
            this.mesaCtlIncorrectoBtn.setDisabled(!this.puedeRechazarConErrores(value));
            this.mesaCtlCorrectoErroresBtn.setDisabled(!this.puedeAceptarConErrores(value));
            this.mesaCtlSolicitarCorreccionBtn.setDisabled(!this.puedeSolicitarCorreccion(value));
        } else {
            this.mesaDeControlMenu.hide();
        }
    },
    
    onCancelar: function(){
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onCancelar] <-');
        }
        var polizaId = this.getForm().findField('Id').getValue();
        Ext.Msg.show({
            title: 'Cancelación',
            msg: 'Esta apunto de realizar una Cancelación',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                    this.doOperationWithParams('DoCancelaOT', polizaId, {
                        fn: function(ot){
                            this.status.setStatus({
                                text: 'La poliza fue cancelada existosamente.',
                                iconCls: 'ok-icon',
                                clear: true
                            });
                            this.updateControls(ot);
                            Ext.MessageBox.alert('Exito', 'La operación de Cancelacion se realizo con exito.');
                        },
                        scope: this
                    });
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[Poliza.onCancelar] ->');
        }
    },
    
    onRenovar: function(){
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[EditorBase.onRenovar] -');
        }
        Ext.Msg.show({
            title: 'Renovación',
            msg: 'Esta apunto de realizar una Renovación',
            buttons: Ext.Msg.YESNO,
            fn: function(result) {
                if (result === 'yes') {
                    this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                    var polizaId = this.getForm().findField('Id').getValue();                    
                    this.doOperationWithParams('DoRenovarPoliza', polizaId, {
                        fn: function(poliza) {                        
                        this.status.setStatus({
                                text: 'La poliza fue renovada existosamente con la OT:. ' + poliza.Id + ', por favor descártela. ',
                                iconCls: 'ok-icon',
                                clear: true
                            });                           
                            this.doClose();                            
                            Ext.MessageBox.alert('Exito', 'La operación de Renovación se realizó con exito, descarte la nueva póliza.', function(){
                                this.entity.onOpen(poliza.Id);
                            }, this);
                        },
                        scope: this
                    });
                }
            },
            animEl: 'elId',
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
    },
    
    onDescartar: function(){
        if (PLOG.isDebugEnabled()) {
            PLOG.debug('[EditorBase.onDescartar] -');                        
        }
        var Total = this.getForm().findField('Prima');
        var Prima = this.getForm().findField('Total');        
        if (Prima.getValue() <= 0 || Total.getValue() <= 0){
            Ext.Msg.alert("Imposible Descartar", "Asigne un valor a la Prima y guarde sus cambios.");
            return false;
        }
        Ext.Msg.show({
            title: 'Descarte de Poliza',
            msg: 'Esta apunto de realizar un descarte',
            buttons: Ext.Msg.YESNO,
            fn: function(result){
                if (result === 'yes') {
                    var desForm = new Cognitum.Polizas.DescartarForm({
                        listeners: {
                            'descartar': {
                                fn: function(folio, generaRecibos, pNetaRecibo1, gastosRecibo1, numRecibos, window){
                                    var polizaId = this.getForm().findField('Id').getValue();
                                    
                                    this.status.showBusy();
									var service = this.entity.service;
									this.entity.service = 'Cognitum.Dominio.Polizas.IPolizaService';
                                    this.doOperationWithParams('DoDescartarOT', [polizaId, folio, generaRecibos, pNetaRecibo1, gastosRecibo1, numRecibos], {
                                        fn: function(poliza){
                                            this.status.setStatus({
                                                text: 'La poliza fue descartada existosamente.',
                                                iconCls: 'ok-icon',
                                                clear: true
                                            });
                                            this.updateControls(poliza);
                                            Ext.MessageBox.alert('Exito', 'La operacion de Descarte se realizo con exito.');
											this.entity.service = service;
                                        },
                                        scope: this
                                    });
                                },
                                scope: this
                            }
                        }
                    });
                    desForm.show();
                }
            },
            icon: Ext.MessageBox.QUESTION,
            scope: this
        });
    },
    
    getTBarDynamicControls: function(value){
        if (value.Id > 0) {
            var cartaEntity = Karma.Core.ModuleManager.Instance.getEntity('Cartas');
            return [{
                fn: cartaEntity.getMenuPoliza,
                params: value.Id,
                scope: cartaEntity
            }];
        }
    }
    
});

Ext.reg('pol.editor', Cognitum.Polizas.General.Editor);
